home *** CD-ROM | disk | FTP | other *** search
/ BCI NET / BCI NET Dec 94.iso / archives / programming / languages / cleo.lzh / Cleo / inter / source / exec.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-01-24  |  23.1 KB  |  726 lines
  1. /***************************************************************************
  2. *   Ce fichier, ainsi que tous les  modules  l'accompagnant, peut et  doit *
  3. * etre  copié GRATUITEMENT à la seule condition expresse de conserver      *
  4. * l'INTEGRALITE  du  Code Source, de  la documentation, et  des fichiers   *
  5. * annexes du package. Ce logiciel est Shareware, veuilez envoyer 100 FF à  *
  6. * l'auteur pour recevoir regulièrement les nouvelles versions.             *
  7. * Toute modification est INTERDITE sans l'autorisation écrite de l'auteur. *
  8. *            Tous droits réservés à M. DIALLO Barrou, Juillet 1992.        *
  9. ***************************************************************************/
  10.  
  11. #ifdef msdos
  12.    #include "include\\inter.h"
  13. #else
  14.    #include "include/inter.h"
  15. #endif
  16.  
  17. extern PRG *prg;
  18. extern MY_CONST *stack;
  19. extern int stsz;
  20. extern Erreur ExecErrs[];
  21. extern int st;
  22. extern int lastcode;
  23. extern Entete head;
  24. extern EXTLIB *lib;
  25.  
  26. extern char *Char;
  27. extern long *Int;
  28. extern double *Real;
  29. extern char **String;
  30.  
  31. extern char *Vchar;
  32. extern unsigned char *Vboolean;
  33. extern int  *Vinteger;
  34. extern double *Vreal;
  35. extern long  *Vlongint;
  36. extern double *Vlongreal;
  37. extern char **Vstring;
  38. extern TAB *Varray;
  39. extern Point3d *Vpoint3d;
  40. extern Point2d *Vpoint2d;
  41. extern Rgb *Vrgb;
  42.  
  43. extern double regReal,regReal2, regReal3, regReal4;
  44. extern double Val[];
  45.  
  46.  
  47. int FindLibFct(int node, double id)
  48. {
  49.     register int n=0, trouve=0;
  50.  
  51.     while (n < head.nbrefctlib && !trouve)
  52.         {
  53.             if (lib[n].node == node && lib[n].id == id)
  54.                 trouve++;
  55.             else
  56.                 n++;
  57.         }
  58.     if (trouve)
  59.         return (n);
  60. }
  61.  
  62. void Error(int num)
  63. {
  64.     printf("** Erreur %d, %s\n", ExecErrs[num].num, ExecErrs[num].msg);
  65.     EndInter();
  66. }
  67.  
  68. void InputVal(void )
  69. {
  70.     int val, val2;
  71.  
  72.     val= (int)PopReal();
  73.     fflush(stdin);
  74.     switch(lastcode)
  75.         {
  76.         case PADR_CHR:
  77.            Vchar[val]=0;
  78.            scanf("%c", &Vchar[val] );
  79.            break;
  80.         case PADR_INT:
  81. /*           Vinteger[val]=0; */
  82.            scanf("%d", &Vinteger[val] );
  83.            break;
  84.         case PADR_LINT:
  85.            Vlongint[val]=0;
  86.            scanf("%ld", &Vlongint[val] );
  87.            break;
  88.         case PADR_REAL:
  89.            Vreal[ (int)val ]=0;
  90.            scanf("%lG", &Vreal[val] );    /* lG */
  91.            break;
  92.         case PADR_LREAL:
  93.            Vlongreal[val]=0;
  94.            scanf("%lG", &Vlongreal[val] );
  95.            break;
  96.         case PADR_STR:
  97.            scanf("%255s", Vstring[val] );
  98.            break;
  99.         case PADR_BOOL:
  100.            Vboolean[val]=0;
  101.            scanf("%c", &Vboolean[val] );
  102.            break;
  103.         case PVAL_INT:              /* last code = index du ADR_ARRAY */
  104.             val2= (int)PopReal();
  105.             switch( Varray[val2 ].tab.type)   /* selon le type */
  106.             {
  107.              case integer_t:
  108.                 scanf("%d",&Varray[val2 ].buf.buf_int[val]);
  109.                 break;
  110.              case real_t:
  111.                 scanf("%lG",&Varray[val2 ].buf.buf_real[val]);
  112.                 break;
  113.              case char_t:
  114.              fflush(stdout); fflush(stdin);
  115.                 Varray[val2 ].buf.buf_char[val] = (char)getchar();
  116.                 break;
  117.              case boolean_t:
  118.                 Varray[val2 ].buf.buf_bool[val] = (char)getchar();
  119.                 break;
  120.             }
  121.             break;
  122.       }
  123. }
  124.  
  125. void PrintVal(void )
  126. {
  127.     fflush(stdout);
  128.     printf("%g", PopReal() ) ;
  129. }
  130.  
  131. void PrintStr(void )
  132. {
  133.     fflush(stdout);
  134.     printf("%s", String[ (int)PopReal()] ) ;
  135.  
  136. }
  137. void PrintVStr(void )
  138. {
  139.     fflush(stdout);
  140.     printf("%s", Vstring[ (int)PopReal()] ) ;
  141.  
  142. }
  143.  
  144. void PrintChr(void )
  145. {
  146.     fflush(stdout);
  147.     printf("%c", (char)PopReal() ) ;
  148.  
  149. }
  150.  
  151.  
  152.  
  153. void Inter(void)
  154. {
  155.     register int pc =0, ope=0;
  156.     char fin=0;
  157.     int str1_type, str1_adr;
  158.     int str2_type, str2_adr;
  159.     char *str1, *str2;
  160.     int infofct;
  161.  
  162.     while (prg[pc].code != RTS && !fin)
  163.     {
  164.         ope = prg[pc].operande;
  165.         switch( prg[pc].code)
  166.         {
  167.         case PVAL_CHR:           /* Push Val N;  Met la Const N dans la pile */
  168.             PushReal(*(Char+ope));
  169.             stack[st-1].type = char_cadr; break;
  170.         case PVAL_INT:
  171.             PushReal(*(Int+ope));
  172.             stack[st-1].type = integer_cadr; break;
  173.         case PVAL_REAL:
  174.             PushReal(*(Real+ope));
  175.             stack[st-1].type = real_cadr; break;
  176.         case PVAL_STR:
  177.             PushReal(ope);
  178.             stack[st-1].type = string_cadr; break;
  179.  
  180.  
  181.         case PADR_CHR:              /* Push l'adr de la var N sur la pile */
  182.             PushReal(ope);
  183.             stack[st-1].type = char_adr; break;
  184.         case PADR_INT:
  185.             PushReal(ope);
  186.             stack[st-1].type = integer_adr; break;
  187.         case PADR_LINT:
  188.             PushReal(ope);
  189.             stack[st-1].type = longint_adr; break;
  190.         case PADR_REAL:
  191.             PushReal(ope);
  192.             stack[st-1].type = real_adr; break;
  193.         case PADR_LREAL:
  194.             PushReal(ope);
  195.             stack[st-1].type = longreal_adr; break;
  196.         case PADR_STR:
  197.             PushReal(ope);
  198.             stack[st-1].type = string_adr; break;
  199.         case PADR_BOOL:
  200.             PushReal(ope);
  201.             stack[st-1].type = boolean_adr; break;
  202.         case PADR_ARRAY:
  203.             PushReal(ope);
  204.             stack[st-1].type = array_adr; break;
  205.         case PADR_P2D:
  206.             PushReal(ope);
  207.             stack[st-1].type = point2d_adr; break;
  208.         case PADR_P3D:
  209.             PushReal(ope);
  210.             stack[st-1].type = point3d_adr; break;
  211.         case PADR_RGB:
  212.             PushReal(ope);
  213.             stack[st-1].type = rgb_adr; break;
  214.  
  215.  
  216.         case PMEM_CHR:    /*charge la val de la var dont l'adr est in pile */
  217.             PushReal( Vchar[(int)PopReal()]);
  218.             stack[st-1].type = char_t; break;
  219.         case PMEM_INT:
  220.             PushReal(Vinteger[(int)PopReal()]);
  221.             stack[st-1].type = integer_t; break;
  222.         case PMEM_LINT:
  223.             PushReal(Vlongint[(int)PopReal()]);
  224.             stack[st-1].type = longint_t; break;
  225.         case PMEM_REAL:
  226.             PushReal(Vreal[(int)PopReal()]);
  227.             stack[st-1].type = real_t; break;
  228.         case PMEM_LREAL:
  229.             PushReal(Vlongreal[(int)PopReal()]);
  230.             stack[st-1].type = longreal_t; break;
  231.         case PMEM_BOOL:
  232.             PushReal(Vboolean[(int)PopReal()]);
  233.             stack[st-1].type = boolean_t; break;
  234.  
  235.         case PMEM_ARRAY:
  236.             regReal = PopReal();             /* index ?*/
  237.             if ( regReal <0.0)     /* Non, tab de struct !!! */
  238.             {
  239.                 regReal2 = regReal;       /* recopie indice du champ*/
  240.                 regReal  = PopReal();     /* index */
  241.                 regReal3  = PopReal();    /* No tab */
  242.                 switch( Varray[(int)regReal3 ].tab.type)   /* selon le type */
  243.                 {
  244.                   case point3d_t:
  245.                     switch( (int)-regReal2-1)      /* selon le champs de la struct */
  246.                     {
  247.                     case 0:
  248.                         PushReal(Varray[(int)regReal3 ].buf.buf_p3d[(int)regReal].x); break;
  249.                     case 1:
  250.                         PushReal(Varray[(int)regReal3 ].buf.buf_p3d[(int)regReal].y); break;
  251.                     case 2:
  252.                         PushReal(Varray[(int)regReal3 ].buf.buf_p3d[(int)regReal].z); break;
  253.                     }
  254.                     break;
  255.                   case point2d_t:
  256.                     switch( (int)-regReal2-1)      /* selon le champs de la struct */
  257.                     {
  258.                     case 0:
  259.                         PushReal(Varray[(int)regReal3 ].buf.buf_p2d[(int)regReal].x); break;
  260.                     case 1:
  261.                         PushReal(Varray[(int)regReal3 ].buf.buf_p2d[(int)regReal].y); break;
  262.                     }
  263.                     break;
  264.                   case rgb_t:
  265.                     switch( (int)-regReal2-1)      /* selon le champs de la struct */
  266.                     {
  267.                     case 0:
  268.                         PushReal(Varray[(int)regReal3 ].buf.buf_rgb[(int)regReal].r); break;
  269.                     case 1:
  270.                         PushReal(Varray[(int)regReal3 ].buf.buf_rgb[(int)regReal].g); break;
  271.                     case 2:
  272.                         PushReal(Varray[(int)regReal3 ].buf.buf_rgb[(int)regReal].b); break;
  273.                     }
  274.                     break;
  275.  
  276.                 }
  277.             }
  278.           else
  279.           {
  280.             regReal2 = PopReal();   /* Numero du Tab*/
  281.  
  282.             switch( Varray[(int)regReal2 ].tab.type)   /* selon le type */
  283.             {
  284.              case integer_t:
  285.                 PushReal(Varray[(int)regReal2 ].buf.buf_int[(int)regReal]);
  286.                 break;
  287.              case real_t:
  288.                 PushReal(Varray[(int)regReal2 ].buf.buf_real[(int)regReal]);
  289.                 break;
  290.              case char_t:
  291.                 PushReal(Varray[(int)regReal2 ].buf.buf_char[(int)regReal]);
  292.                 break;
  293.              case boolean_t:
  294.                 PushReal(Varray[(int)regReal2 ].buf.buf_bool[(int)regReal]);
  295.                 break;
  296.             }
  297.       } /* else */
  298.       stack[st-1].type = array_t;
  299.       break;
  300.  
  301.        case PMEM_P3D_ALL:
  302.                 regReal = PopReal();      /* No de la structure */
  303.                 PushReal(Vpoint3d[ (int) regReal].x);
  304.                 PushReal(Vpoint3d[ (int) regReal].y);
  305.                 PushReal(Vpoint3d[ (int) regReal].z);
  306.                 break;
  307.  
  308.        case PMEM_P2D_ALL:
  309.                 regReal = PopReal();      /* No de la structure */
  310.                 PushReal(Vpoint3d[ (int) regReal].x);
  311.                 PushReal(Vpoint3d[ (int) regReal].y);
  312.                 break;
  313.        case PMEM_RGB_ALL:
  314.                 regReal = PopReal();      /* No de la structure */
  315.                 PushReal(Vrgb[ (int)regReal].r);
  316.                 PushReal(Vrgb[ (int)regReal].g);
  317.                 PushReal(Vrgb[ (int)regReal].b);
  318.                 break;
  319.  
  320.        case PMEM_RGB:
  321.             regReal2 = PopReal();     /* Numero du champs*/
  322.             regReal = PopReal();      /* No de la structure */
  323.             switch( (int)regReal2)  /* champs r, g ou b ? */
  324.             {
  325.               case 0:
  326.                 PushReal(Vrgb[ (int) regReal].r); break;
  327.               case 1:
  328.                 PushReal(Vrgb[ (int) regReal].g); break;
  329.               case 2:
  330.                 PushReal(Vrgb[ (int) regReal].b); break;
  331.             }
  332.          stack[st-1].type = rgb_t;
  333.          break;
  334.  
  335.        case PMEM_P3D:
  336.             regReal2 = PopReal();     /* Numero du champs*/
  337.             regReal = PopReal();      /* No de la structure */
  338.             switch( (int)regReal2)  /* champs x, y ou z ? */
  339.             {
  340.               case 0:
  341.                 PushReal(Vpoint3d[ (int) regReal].x); break;
  342.             case 1:
  343.                 PushReal(Vpoint3d[ (int) regReal].y); break;
  344.             case 2:
  345.                 PushReal(Vpoint3d[ (int) regReal].z); break;
  346.             }
  347.          stack[st-1].type = point3d_t;
  348.          break;
  349.  
  350.        case PMEM_P2D:
  351.             regReal2 = PopReal(); /* Numero du champs*/
  352.             regReal = PopReal();   /* No de la structure */
  353.             switch( (int)regReal2)  /* champs x ou y ? */
  354.             {
  355.             case 0:
  356.                 PushReal(Vpoint2d[ (int) regReal].x); break;
  357.             case 1:
  358.                 PushReal(Vpoint2d[ (int) regReal].y); break;
  359.             }
  360.          stack[st-1].type = point2d_t;
  361.          break;
  362.  
  363.  
  364. /*        case PMEM_STR:
  365.             PushReal(Vstring[(int)PopReal()]); break;     */
  366.  
  367.         case PRSTR:
  368.             PrintStr(); break;
  369.         case PRVSTR:
  370.             PrintVStr(); break;
  371.         case PRCHR:
  372.             PrintChr(); break;
  373.         case PRINT:
  374.             PrintVal(); break;
  375.         case PRINTCHR:
  376.             PrintChr(); break;
  377.         case CHR13:
  378.             printf("\n"); break;
  379.         case READ:
  380.             InputVal(); break;
  381.  
  382.         case STM_CHR:      /*Val in variable dont l'adr est a pile-1*/
  383.              regReal = PopReal();
  384.              Vchar[ (int) PopReal()] = regReal;
  385.              break;
  386.         case STM_INT:
  387.              regReal = PopReal();
  388.              Vinteger[ (int) PopReal()] = regReal;
  389.              break;
  390.         case STM_LINT:
  391.              regReal = PopReal();
  392.              Vlongint[ (int) PopReal()] = regReal;
  393.              break;
  394.         case STM_REAL:
  395.              regReal = PopReal();
  396.              Vreal[ (int)PopReal()] = regReal;
  397.              break;
  398.         case STM_LREAL:
  399.              regReal = PopReal();
  400.              Vlongreal[ (int) PopReal()] = regReal;
  401.              break;
  402.         case STM_BOOL:
  403.              regReal = PopReal();
  404.              Vboolean[ (int) PopReal()] = regReal;
  405.              break;
  406.         case STM_STR:
  407.              regReal = PopReal();   /* Adr du string */
  408.              regReal2 = PopReal();  /* adr de la variable string */
  409.              Vstring[ (int)regReal2 ] = (char *)calloc(MAXSTRING,1);
  410.              if (lastcode== PVAL_STR)  /* c'est une constante */
  411.                 strcpy( Vstring[ (int)regReal2 ], String[(int)regReal]);
  412.              else
  413.                 strcpy( Vstring[ (int)regReal2 ], Vstring[(int)regReal]);
  414.              break;
  415.  
  416.         case STM_ARRAY:
  417.              regReal = PopReal();    /* Valeur a mettre */
  418.              regReal2 = PopReal();   /* index du tab ? */
  419.              if ( regReal2 <0.0)
  420.              {
  421.                 regReal3 = PopReal();   /* index du tab  */
  422.                 regReal4 = PopReal();   /* No du tab  */
  423.                 switch( Varray[(int)regReal4 ].tab.type)   /* selon le type */
  424.                 {
  425.                 case point3d_t:
  426.                     switch ( (int)-regReal2-1)
  427.                     {
  428.                     case 0:
  429.                         Varray[ (int) regReal4 ].buf.buf_p3d[ (int)regReal3 ].x = regReal; break;
  430.                     case 1:
  431.                         Varray[ (int) regReal4 ].buf.buf_p3d[ (int)regReal3 ].y = regReal; break;
  432.                     case 2:
  433.                         Varray[ (int) regReal4 ].buf.buf_p3d[ (int)regReal3 ].z = regReal; break;
  434.                     }
  435.                     break;
  436.                 case point2d_t:
  437.                     switch ( (int)-regReal2-1)
  438.                     {
  439.                     case 0:
  440.                         Varray[ (int) regReal4 ].buf.buf_p2d[ (int)regReal3 ].x = regReal;
  441.                     break;
  442.                     case 1:
  443.                         Varray[ (int) regReal4 ].buf.buf_p2d[ (int)regReal3 ].y = regReal;
  444.                     break;
  445.                     }
  446.                     break;
  447.                 case rgb_t:
  448.                     switch ( (int)-regReal2-1)
  449.                     {
  450.                     case 0:
  451.                         Varray[ (int) regReal4 ].buf.buf_rgb[ (int)regReal3 ].r = regReal; break;
  452.                     case 1:
  453.                         Varray[ (int) regReal4 ].buf.buf_rgb[ (int)regReal3 ].g = regReal; break;
  454.                     case 2:
  455.                         Varray[ (int) regReal4 ].buf.buf_rgb[ (int)regReal3 ].b = regReal; break;
  456.                     }
  457.                     break;
  458.  
  459.                  }
  460.            break; /* quit STM case */
  461.              }
  462.              regReal3 = PopReal();   /* numero du tab */
  463.  
  464.             switch( Varray[(int)regReal3 ].tab.type)   /* selon le type */
  465.             {
  466.              case integer_t:
  467.                 Varray[ (int) regReal3 ].buf.buf_int[ (int)regReal2 ] = regReal;
  468.                 break;
  469.              case real_t:
  470.                 Varray[ (int) regReal3 ].buf.buf_real[ (int)regReal2 ] = regReal;
  471.                 break;
  472.              case char_t:
  473.                 Varray[ (int) regReal3 ].buf.buf_char[ (int)regReal2 ] = regReal;
  474.                 break;
  475.              case boolean_t:
  476.                 Varray[ (int) regReal3 ].buf.buf_bool[ (int)regReal2 ] = regReal;
  477.                 break;
  478.             }
  479.              break;
  480.  
  481.         case STM_P3D:
  482.             if (lastcode == PMEM_P3D_ALL)
  483.             {
  484.              *Val = PopReal();       /* z */
  485.              *(Val+1) = PopReal();   /* y */
  486.              *(Val+2) = PopReal();   /* x */
  487.              regReal = PopReal();    /* numero de la structure */
  488.  
  489.              Vpoint3d[ (int)regReal ].x = Val[2];  /* x */
  490.              Vpoint3d[ (int)regReal ].y = Val[1];  /* y */
  491.              Vpoint3d[ (int)regReal ].z = Val[0];  /* z */
  492.              break;
  493.             }
  494.              regReal = PopReal();    /* Valeur a mettre dans le champs*/
  495.              regReal2 = PopReal();   /* index du champs */
  496.              regReal3 = PopReal();   /* numero de la structure */
  497.  
  498.              switch((int)regReal2)
  499.              {
  500.              case 0 : Vpoint3d[ (int)regReal3 ].x = regReal; break;  /* x */
  501.              case 1 : Vpoint3d[ (int)regReal3 ].y = regReal; break;  /* y */
  502.              case 2 : Vpoint3d[ (int)regReal3 ].z = regReal; break;  /* z */
  503.              }
  504.              break;
  505.  
  506.         case STM_P2D:
  507.             if (lastcode == PMEM_P2D_ALL)
  508.             {
  509.              Val[1] = PopReal();   /* y */
  510.              Val[2] = PopReal();   /* x */
  511.              regReal = PopReal();   /* numero de la structure */
  512.  
  513.              Vpoint3d[ (int)regReal ].x = Val[2];  /* x */
  514.              Vpoint3d[ (int)regReal ].y = Val[1];  /* y */
  515.              break;
  516.             }
  517.              regReal = PopReal();    /* Valeur a mettre dans le champs*/
  518.              regReal2 = PopReal();   /* index du champs */
  519.              regReal3 = PopReal();   /* numero de la structure */
  520.  
  521.              switch((int)regReal2)
  522.              {
  523.              case 0 : Vpoint2d[ (int)regReal3 ].x = regReal; break;  /* x */
  524.              case 1 : Vpoint2d[ (int)regReal3 ].y = regReal; break;  /* y */
  525.              }
  526.              break;
  527.  
  528.         case STM_RGB:
  529.             if (lastcode == PMEM_RGB_ALL)
  530.             {
  531.              *Val = PopReal();       /* r */
  532.              *(Val+1) = PopReal();   /* g */
  533.              *(Val+2) = PopReal();   /* b */
  534.              regReal = PopReal();    /* numero de la structure */
  535.  
  536.              Vrgb[ (int)regReal ].r = Val[2];  /* r */
  537.              Vrgb[ (int)regReal ].g = Val[1];  /* g */
  538.              Vrgb[ (int)regReal ].b = Val[0];  /* b */
  539.              break;
  540.             }
  541.              regReal = PopReal();    /* Valeur a mettre dans le champs*/
  542.              regReal2 = PopReal();   /* index du champs */
  543.              regReal3 = PopReal();   /* numero de la structure */
  544.  
  545.              switch((int)regReal2)
  546.              {
  547.              case 0 : Vrgb[ (int)regReal3 ].r = regReal; break;  /* r */
  548.              case 1 : Vrgb[ (int)regReal3 ].g = regReal; break;  /* g */
  549.              case 2 : Vrgb[ (int)regReal3 ].b = regReal; break;  /* b */
  550.              }
  551.              break;
  552.  
  553.         case DIVS :
  554.              regReal = 1/PopReal();
  555.              PushReal(regReal*PopReal()); break;
  556.         case DIV :
  557.              regReal = 1/PopReal();
  558.              PushReal((int)(regReal*PopReal())); break;
  559.         case MOD :
  560.              regReal = PopReal();
  561.              PushReal( ((int)regReal) % ((int)PopReal())); break;
  562.         case MULS :
  563.              PushReal(PopReal()*PopReal()); break;
  564.         case ADD :
  565.              PushReal(PopReal()+PopReal()); break;
  566.         case SUB:
  567.              regReal = -PopReal();
  568.              PushReal(regReal+PopReal()); break;
  569.         case NEG:
  570.              PushReal(-PopReal()); break;
  571.  
  572.         case EQU:
  573.             if (PopReal()==PopReal())
  574.                PushReal(1);
  575.             else
  576.                PushReal(0);
  577.             break;
  578.         case LT:
  579.             if (PopReal()>PopReal())
  580.                PushReal(1);
  581.             else
  582.                PushReal(0);
  583.             break;
  584.  
  585.         case GT:
  586.             if (PopReal()<PopReal())
  587.                PushReal(1);
  588.             else
  589.                PushReal(0);
  590.             break;
  591.         case LE:
  592.             if (PopReal()>=PopReal())
  593.                PushReal(1);
  594.             else
  595.                PushReal(0);
  596.             break;
  597.         case GE:
  598.             if (PopReal()<=PopReal())
  599.                PushReal(1);
  600.             else
  601.                PushReal(0);
  602.             break;
  603.         case NE:
  604.             if (PopReal()!=PopReal())
  605.                PushReal(1);
  606.             else
  607.                PushReal(0);
  608.             break;
  609.  
  610.         case BRA:
  611.             pc  = ope-1; break;
  612.         case BNE:
  613.             if (!PopReal())
  614.                 pc  = ope-1;
  615. /*            else
  616.                 if ( prg[pc].code != RTS)
  617.                     Error(UNKNOW);                    */
  618.             break;
  619.         case EQU_STR:
  620.             str1_type = stack[st-1].type; str1_adr = PopReal();
  621.             str2_type = stack[st-1].type; str2_adr = PopReal();
  622.  
  623.             if (str1_type == string_adr)
  624.                 str1= (char*) Vstring[str1_adr];
  625.             else
  626.                 str1= (char*) String[str1_adr];
  627.  
  628.             if (str2_type == string_adr)
  629.                 str2= (char*) Vstring[str2_adr];
  630.             else
  631.                 str2= (char*) String[str2_adr];
  632.  
  633.             if ( !(strcmp(str1,str2)))
  634.                PushReal(1);
  635.             else
  636.                PushReal(0);
  637.             break;
  638.  
  639.         case LT_STR:
  640.         case GT_STR:
  641.         case LE_STR:
  642.         case GE_STR:
  643.             break;
  644.         case AND:
  645.              PushReal((int)PopReal() & (int)PopReal()); break;
  646.         case OR:
  647.              PushReal((int)PopReal() | (int)PopReal()); break;
  648.         case XOR:
  649.              PushReal((int)PopReal() ^ (int)PopReal()); break;
  650.         case NOT:
  651.              PushReal(~((int)PopReal())); break;
  652.         case IN:
  653.             break;
  654.  
  655.         case SQR:       /* a*a */
  656.                 regReal = PopReal();
  657.              PushReal(regReal*regReal); break;
  658.         case SQRT:      /* Racine de a */
  659.              PushReal(sqrt(PopReal())); break;
  660.         case ABS:
  661.              PushReal(fabs(PopReal())); break;
  662.  
  663.         case COS:
  664.              PushReal(cos(PopReal())); break;
  665.         case SIN:
  666.              PushReal(sin(PopReal())); break;
  667.         case TAN:
  668.              PushReal(tan(PopReal())); break;
  669.         case ACOS:
  670.              PushReal(acos(PopReal())); break;
  671.         case ASIN:
  672.              PushReal(asin(PopReal())); break;
  673.         case ATAN:
  674.              PushReal(atan(PopReal())); break;
  675.         case COSH:
  676.              PushReal(cosh(PopReal())); break;
  677.         case SINH:
  678.              PushReal(sinh(PopReal())); break;
  679.         case TANH:
  680.              PushReal(tanh(PopReal())); break;
  681.         case LN:
  682.              PushReal(log(PopReal())); break;
  683.         case EXP:
  684.              PushReal(exp(PopReal())); break;
  685.         case FRAC:
  686.             regReal = PopReal();
  687.             PushReal (regReal-(int)regReal);
  688.             break;
  689.         case INT:
  690.              PushReal( (int)PopReal()); break;
  691.  
  692.         case ODD:
  693.             regReal = PopReal();
  694.             if (regReal/2.0 == (int)(regReal/2.0))
  695.                 PushReal(0.0);
  696.             else PushReal(1.0);
  697.             break;
  698.         case EVEN:
  699.             regReal = PopReal();
  700.             if (regReal/2.0 == (int)(regReal/2.0))
  701.                 PushReal(1.0);
  702.             else PushReal(0.0);
  703.             break;
  704.         case PRED:
  705.              PushReal( PopReal()-1); break;
  706.         case SUCC:
  707.              PushReal( PopReal()+1); break;
  708.         case INV:
  709.              PushReal( 1.0/PopReal()); break;
  710.         case RND:             /* not implemented cause UNIX, AMIGA... */
  711.             break;
  712.         case RTS:
  713.             fin=1; break;
  714.         case PUSHVAL:
  715.              PushReal(ope); break;
  716.         case LIBRARY:
  717.             infofct=FindLibFct( ope, PopReal());     /* Trouve la fct de la lib qui correspond */
  718.             break;
  719.     }
  720.     lastcode= prg[pc].code;
  721.     pc++;
  722.     }
  723.   EndInter();
  724. }
  725.  
  726.